跳到主要内容

GPIO

Luckfox‑Lume 基于全志 T153 芯片,本章我们将学习如何使用 sysfs 文件系统来访问和控制 GPIO。

1. GPIO 子系统简介​

GPIO(General‑Purpose Input/Output,通用输入 / 输出)是一类可由处理器控制的可编程数字引脚,支持输出高低电平、检测外部输入电平。引脚经过复用配置后,也可以切换为串口、I2C、SPI 等外设功能。

在 Linux 系统中,内核提供了专门的 GPIO 子系统驱动框架,用于统一管理处理器的 GPIO 资源。基于该框架,开发者既可以在内核空间驱动中操作引脚,也能够将 GPIO 开放至用户空间进行控制。

用户空间可通过 sysfs 文件系统接口对 GPIO 引脚进行读写控制。GPIO 配置为输出时,可控制 LED、继电器等外设;配置为输入时,既可读取普通电平信号,也支持边沿中断检测,用于按键、外部传感器事件捕获等场景。依托 GPIO 子系统,引脚功能具备高度的灵活性与可编程性。

如需深入了解 Linux GPIO 子系统的实现原理,可参考内核源码文档:<Linux内核源码>/Documentation/driver-api/gpio/

2. GPIO 控制(Shell)​

2.1 引脚分布​

2.2 GPIO 编号计算​

T153主GPIO每个Bank预留32个线号:

PA = 0, PB = 1, PC = 2, PD = 3, ...
line = Bank序号 * 32 + 引脚序号

例如 PD16 = 3 * 32 + 16 = 112。

2.3 使用 GPIO sysfs 接口​

  1. 以物理引脚11、PD16、线号112作示例,将 GPIO 控制从内核空间导出到用户空间:

    echo 112 > /sys/class/gpio/export
    ls /sys/class/gpio/gpio112
  2. 导出成功后会生成 /sys/class/gpio/gpio112/:

    active_low direction power uevent
    device edge subsystem value
  3. 取消GPIO 控制从内核空间到用户空间的导出:

    echo 112 > /sys/class/gpio/unexport

2.4 设备目录和设备属性​

  1. 向 /sys/class/gpio/export 写入目标GPIO的全局编号,内核会申请该GPIO并创建用户空间控制节点,而不是强制释放其他驱动已经占用的引脚。已被占用时可能返回 Device or resource busy。导出成功后,用户通过 /sys/class/gpio/gpio<编号> 中的属性文件配置方向和读写电平。
    root@luckfox:~# ls /sys/class/gpio/
    export gpiochip0 gpiochip400 gpiochip704 gpio112 unexport
  2. 引脚导出成功后会生成 /sys/class/gpio/gpio<N> 设备目录,其中 N 为 GPIO 全局编号;目录内包含一组可读写的属性节点,用户空间可通过操作这些属性,实现 GPIO 引脚的配置与电平控制。
    root@luckfox:~# ls /sys/class/gpio/gpio112/
    active_low direction power uevent
    device edge subsystem value
    • direction:GPIO 方向控制节点。写入in将引脚配置为输入模式;写入out将引脚配置为输出模式。
    • value:GPIO 电平节点。输入模式时读取该文件可获取引脚实时电平;输出模式时写入1或0,控制引脚输出高低电平。电平逻辑受active_low属性影响。
    • active_low:0表示正常逻辑,1表示反向逻辑。本章高、低电平的预期结果以两个GPIO的 active_low 均为0为前提;现有示例不会主动修改这个属性。
    • edge:边沿检测配置节点,仅输入模式有效。设置边沿触发条件后,用户程序可通过poll()、select()监听引脚电平变化;仅配置 edge 属性并不会产生硬件中断回调。
      • rising:上升沿触发
      • falling:下降沿触发
      • both:双边沿触发
      • none:禁用边沿检测

2.5 控制输出电平​

  1. 设置方向:
    cd /sys/class/gpio/gpio112

    echo out > direction # 设置 GPIO 为输出
    echo in > direction # 设置 GPIO 为输入
  2. 设置value属性来控制 GPIO 电平:
    cat value

    echo 0 > value
    echo 1 > value

2.6 读取输入电平​

cd /sys/class/gpio/gpio112
echo in > direction
cat value

3. 控制 GPIO(Python 程序)​

  1. 示例程序:使用两个 GPIO 进行硬件回环测试:PC7 输出高、低电平,PD16 读取输入电平。Python 和 C 均使用以下 Lume 接线,断电后短接物理引脚16与11。

    功能GPIO 全局线号Lume GPIO40Pin 物理引脚
    输出71PC716
    输入112PD1611
    #!/usr/bin/env python3
    from pathlib import Path
    import time

    OUT_PIN = 71
    IN_PIN = 112

    SYSFS_ROOT = Path("/sys/class/gpio")

    def gpio_export(line: int) -> bool:
    gpio_dir = SYSFS_ROOT / f"gpio{line}"
    if gpio_dir.exists():
    print(f"gpio {line} already exported, reusing")
    return False
    (SYSFS_ROOT / "export").write_text(str(line))
    time.sleep(0.1)
    return True

    def gpio_unexport(line: int):
    path = SYSFS_ROOT / "unexport"
    if (SYSFS_ROOT / f"gpio{line}").exists():
    path.write_text(str(line))

    def gpio_set_dir(line:int, direction:str):
    p = SYSFS_ROOT / f"gpio{line}" / "direction"
    p.write_text(direction)

    def gpio_set_value(line:int, val:int):
    p = SYSFS_ROOT / f"gpio{line}" / "value"
    p.write_text(str(val))

    def gpio_read_value(line:int) -> int:
    p = SYSFS_ROOT / f"gpio{line}" / "value"
    return int(p.read_text().strip())

    out_owned = gpio_export(OUT_PIN)
    in_owned = gpio_export(IN_PIN)

    try:
    gpio_set_dir(OUT_PIN, "out")
    gpio_set_dir(IN_PIN, "in")

    print(f"Loop‑back test start: OUT={OUT_PIN}, IN={IN_PIN}")
    print(f"Short {OUT_PIN} <--> {IN_PIN}\n")

    while True:
    gpio_set_value(OUT_PIN, 1)
    read_back = gpio_read_value(IN_PIN)
    print(f"HIGH, hardware readback = {read_back}")
    time.sleep(0.5)

    gpio_set_value(OUT_PIN, 0)
    read_back = gpio_read_value(IN_PIN)
    print(f"LOW, hardware readback = {read_back}")
    time.sleep(0.5)

    except KeyboardInterrupt:
    print("\nUser stop test.")
    finally:
    gpio_set_value(OUT_PIN,0)
    if out_owned: gpio_unexport(OUT_PIN)
    if in_owned: gpio_unexport(IN_PIN)

  2. 打开并配置 GPIO:

    out_owned = gpio_export(OUT_PIN)
    in_owned = gpio_export(IN_PIN)
    gpio_set_dir(OUT_PIN, "out")
    gpio_set_dir(IN_PIN, "in")

    程序中先导出PC7和PD16,再将PC7设为输出、PD16设为输入:

    • gpio_export(line):检查 gpio<line> 目录。若目录已存在(其他程序已导出),打印提示并返回 False,不标记所有权;否则向 export 写入线号,等待0.1秒后返回 True。
    • gpio_set_dir(line, direction):将 out 或 in 写入对应的 direction 文件。
    • Path.write_text():打开属性文件、写入文本并关闭文件。
  3. 控制输出并读取输入:

    gpio_set_value(OUT_PIN, 1)
    read_back = gpio_read_value(IN_PIN)
    print(f"HIGH, hardware readback = {read_back}")
    time.sleep(0.5)

    gpio_set_value(OUT_PIN, 0)
    read_back = gpio_read_value(IN_PIN)
    print(f"LOW, hardware readback = {read_back}")
    time.sleep(0.5)

    gpio_set_value() 将整数转换为文本,写入PC7的 value 文件。gpio_read_value() 读取PD16的 value。

  4. 结束测试并释放资源:

    except KeyboardInterrupt:
    print("\nUser stop test.")
    finally:
    gpio_set_value(OUT_PIN, 0)
    if out_owned: gpio_unexport(OUT_PIN)
    if in_owned: gpio_unexport(IN_PIN)

    按 Ctrl+C 结束循环。退出前将输出引脚拉低,再只取消本程序拥有所有权的 GPIO 的导出,避免影响其他程序控制的 GPIO。

  5. 运行Python程序:

    python3 GPIO.py

    运行结果:

4. 控制 GPIO(C 程序)​

  1. 完整代码:

    #define _DEFAULT_SOURCE
    #include <errno.h>
    #include <fcntl.h>
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>

    #define OUT_LINE 71
    #define IN_LINE 112

    static volatile sig_atomic_t stop_test = 0;

    struct gpio_pin {
    int line;
    int owned;
    int output;
    char value_path[80];
    };

    static void stop_handler(int sig)
    {
    (void)sig;
    stop_test = 1;
    }

    static int write_text(const char *path, const char *text)
    {
    int fd = open(path, O_WRONLY);
    if (fd < 0) {
    perror(path);
    return -1;
    }
    size_t size = strlen(text);
    ssize_t count = write(fd, text, size);
    int saved_errno = errno;
    if (count != (ssize_t)size) {
    close(fd);
    errno = count < 0 ? saved_errno : EIO;
    perror(path);
    return -1;
    }
    if (close(fd) < 0) {
    perror(path);
    return -1;
    }
    return 0;
    }

    static int open_gpio(struct gpio_pin *pin, const char *direction)
    {
    char path[80], number[16];
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d", pin->line);
    if (access(path, F_OK) == 0) {
    fprintf(stderr, "GPIO%d already exported; check its owner\n",
    pin->line);
    return -1;
    }
    snprintf(number, sizeof(number), "%d", pin->line);
    if (write_text("/sys/class/gpio/export", number) < 0)
    return -1;
    pin->owned = 1;

    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/direction",
    pin->line);
    for (int i = 0; i < 100 && access(path, F_OK) != 0; ++i)
    usleep(1000);
    if (write_text(path, direction) < 0)
    return -1;
    pin->output = strcmp(direction, "out") == 0;
    snprintf(pin->value_path, sizeof(pin->value_path),
    "/sys/class/gpio/gpio%d/value", pin->line);
    return 0;
    }

    static int read_gpio(const struct gpio_pin *pin, int *value)
    {
    char c;
    int fd = open(pin->value_path, O_RDONLY);
    if (fd < 0) {
    perror(pin->value_path);
    return -1;
    }
    ssize_t count = read(fd, &c, 1);
    int saved_errno = errno;
    close(fd);
    if (count != 1 || (c != '0' && c != '1')) {
    errno = count < 0 ? saved_errno : EIO;
    perror(pin->value_path);
    return -1;
    }
    *value = c == '1';
    return 0;
    }

    static int close_gpio(struct gpio_pin *pin)
    {
    char number[16];
    int result = 0;
    if (!pin->owned)
    return 0;
    if (pin->output && write_text(pin->value_path, "0") < 0)
    result = -1;
    snprintf(number, sizeof(number), "%d", pin->line);
    if (write_text("/sys/class/gpio/unexport", number) < 0)
    result = -1;
    pin->owned = 0;
    return result;
    }

    int main(void)
    {
    struct gpio_pin out_pin = { .line = OUT_LINE };
    struct gpio_pin in_pin = { .line = IN_LINE };
    int result = EXIT_FAILURE;
    int read_back;

    signal(SIGINT, stop_handler);
    setvbuf(stdout, NULL, _IOLBF, 0);

    if (open_gpio(&in_pin, "in") < 0)
    goto cleanup;
    if (stop_test) {
    result = EXIT_SUCCESS;
    goto cleanup;
    }
    if (open_gpio(&out_pin, "out") < 0)
    goto cleanup;

    while (!stop_test) {
    if (write_text(out_pin.value_path, "1") < 0 ||
    read_gpio(&in_pin, &read_back) < 0)
    goto cleanup;
    printf("HIGH, hardware readback = %s\n",
    read_back ? "True" : "False");
    usleep(500000);
    if (stop_test)
    break;

    if (write_text(out_pin.value_path, "0") < 0 ||
    read_gpio(&in_pin, &read_back) < 0)
    goto cleanup;
    printf("LOW, hardware readback = %s\n",
    read_back ? "True" : "False");
    usleep(500000);
    }
    result = EXIT_SUCCESS;

    cleanup:
    if (stop_test)
    puts("\nUser stop test.");
    if (close_gpio(&out_pin) < 0)
    result = EXIT_FAILURE;
    if (close_gpio(&in_pin) < 0)
    result = EXIT_FAILURE;
    return result;
    }
  2. 导出引脚到用户空间,open_gpio() 按输入112、输出71的顺序执行:

    if (access(path, F_OK) == 0) {
    fprintf(stderr, "GPIO%d already exported; check its owner\n",
    pin->line);
    return -1;
    }
    snprintf(number, sizeof(number), "%d", pin->line);
    if (write_text("/sys/class/gpio/export", number) < 0)
    return -1;
    pin->owned = 1;

    write_text() 使用 open()、write()、close() 操作sysfs文件,并检查打开、写入长度及关闭结果。失败时用 perror() 输出原因并返回-1;内核占用导致的 EBUSY 也作为错误处理,而不是强制接管。

  3. 配置 GPIO 方向:

    if (open_gpio(&in_pin, "in") < 0)
    goto cleanup;
    if (open_gpio(&out_pin, "out") < 0)
    goto cleanup;

    PD16为输入、PC7为输出,先配置输入端。初始化部分失败时,也会进入清理流程,避免留下已导出的GPIO。

  4. 控制输出电平并读取输入:

    if (write_text(out_pin.value_path, "1") < 0 ||
    read_gpio(&in_pin, &read_back) < 0)
    goto cleanup;
    printf("HIGH, hardware readback = %s\n",
    read_back ? "True" : "False");
    usleep(500000);
  5. 取消导出引脚:

    if (close_gpio(&out_pin) < 0)
    result = EXIT_FAILURE;
    if (close_gpio(&in_pin) < 0)
    result = EXIT_FAILURE;
    return result;
  6. 交叉编译:Luckfox Lume SDK 使用ARM32工具链。

    export PATH=<Luckfox_Lume_SDK>/out/toolchain/gcc-linaro-11.3.1-2022.06-x86_64_arm-linux-gnueabihf/bin:$PATH

    编译程序:

    arm-linux-gnueabihf-gcc -Wall -Wextra -O2 GPIO.c -o GPIO
    file GPIO
  7. 传输并运行:

    scp GPIO root@<LUME_IP>:/root/

    将 <LUME_IP> 替换为开发板地址,例如 192.168.9.152,目标路径为开发板的 /root/GPIO。

  8. 运行C程序:

    chmod +x /root/GPIO
    /root/GPIO

    运行结果: